package cn.rxyb.boot.redis;

import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import java.util.*;

/**
 * redis String类型工具类
 *
 * @author lcf
 * @date 2020/6/5
 */
@Slf4j
public class GetRedisToBean extends BaseRedisUtils {


    /**
     * 获取值
     *
     * @param key 获取 key 是否存在
     * @param cls 获取值得类型
     * @return
     */

    public <T> Optional<T> get(String key, Class<T> cls) {
        if (redisTemplate.hasKey(key)) {
            return Optional.of(JSONUtil.toBean(JSONUtil.toJsonStr(redisTemplate.opsForValue().get(key)), cls));
        }
        log.warn("redis key [{}] 不存在", key);
        return Optional.empty();
    }

    /**
     * 获取值
     *
     * @param key 获取key 是否存在
     * @return
     */
    public Optional<String> get(String key) {
        if (redisTemplate.hasKey(key)) {
            return Optional.of(redisTemplate.opsForValue().get(key).toString());
        }
        log.warn("redis key [{}] 不存在", key);
        return Optional.empty();
    }


    /**
     * 获取list 第一个key 得值
     *
     * @return
     */
    public Optional<String> getListFirst(String key) {
        if (redisTemplate.hasKey(key)) {
            return Optional.of(redisTemplate.opsForList().index(key, 0).toString());
        }
        return Optional.empty();
    }

    /**
     * 获取list 最一个key 得值
     *
     * @return
     */
    public Optional<String> getListLast(String key) {
        if (redisTemplate.hasKey(key)) {
            Optional<List> matchKeys = this.getList(key);
            if (matchKeys.isPresent()) {
                return Optional.of(matchKeys.get().get(matchKeys.get().size() - 1).toString());
            }
        }
        return Optional.empty();
    }

    /**
     * 获取list 第一个key 得值
     *
     * @param key 键
     * @param cls 泛型
     * @param <T>
     * @return
     */
    public <T> Optional<T> getListFirst(String key, Class<T> cls) {
        if (redisTemplate.hasKey(key)) {
            return Optional.of(JSONUtil.toBean(JSONUtil.toJsonStr(redisTemplate.opsForList().index(key, 0)), cls));
        }
        return Optional.empty();
    }


    /**
     * 获取list 第一个key 得值
     *
     * @param key 键
     * @param cls 泛型
     * @param <T>
     * @return
     */
    public <T> Optional<T> getListLast(String key, Class<T> cls) {
        if (redisTemplate.hasKey(key)) {
            Optional<List> matchKeys = this.getList(key);
            if (matchKeys.isPresent()) {
                Object o = matchKeys.get().get(matchKeys.get().size() - 1);
                return Optional.of(JSONUtil.toBean(JSONUtil.toJsonStr(o), cls));
            }
        }
        return Optional.empty();
    }

    /**
     * 获取list 所有得值
     *
     * @return
     */
    public Optional<List> getList(String key) {
        if (redisTemplate.hasKey(key)) {
            return Optional.of(redisTemplate.opsForList().range(key, 0, -1));
        }
        return Optional.empty();
    }

    /**
     * 获取list 所有得值
     *
     * @param key ket
     * @param cls 泛型
     * @param <T>
     * @return 返回
     */
    public <T> Optional<List<T>> getList(String key, Class<T> cls) {
        if (redisTemplate.hasKey(key)) {
            return Optional.of(redisTemplate.opsForList().range(key, 0, -1));
        }
        return Optional.empty();
    }

    /************************hash 获取值************************************/

    /**
     * 获取 Hash 第一个key 得值
     *
     * @return
     */
    public Optional<String> getHashFirst(String key, String hashKey) {
        if (redisTemplate.hasKey(key)) {
            return Optional.of(redisTemplate.opsForHash().get(key, hashKey).toString());
        }
        return Optional.empty();
    }

    /**
     * 获取Hash 第一个key 得值
     *
     * @param key     键
     * @param hashKey hashKey hash键
     * @param cls     泛型
     * @param <T>
     * @return
     */
    public <T> Optional<T> getHashFirst(String key, String hashKey, Class<T> cls) {
        if (redisTemplate.hasKey(key)) {
            return Optional.of(JSONUtil.toBean(JSONUtil.toJsonStr(redisTemplate.opsForHash().get(key, hashKey).toString()), cls));
        }
        return Optional.empty();
    }


    /**
     * 获取Hash 所有得值
     *
     * @return
     */
    public Optional<Map<String, Object>> getHash(String key) {
        if (redisTemplate.hasKey(key)) {
            return Optional.of(redisTemplate.opsForHash().entries(key));
        }
        return Optional.empty();
    }

    /**
     * 获取Hash 所有得值
     *
     * @param key ket
     * @param cls 泛型
     * @param <T>
     * @return 返回
     */
    public <T> Optional<Map<String, T>> getHash(String key, Class<T> cls) {
        if (redisTemplate.hasKey(key)) {
            return Optional.of(redisTemplate.opsForHash().entries(key));
        }
        return Optional.empty();
    }


}
